'use strict';

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

// es6提供了新的数据结构Set
// 无重复的值，和数组类似
var s = new Set();
var arr = [1, 3, 4, 5, 5];
arr.forEach(function (x) {
  // 向Set结构添加成员，企鹅不会有重复的成员
  s.add(x);
});
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;

try {
  for (var _iterator = s[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
    var i = _step.value;
  }
  // console.log(i)


  // 2. 接收一个数组作为参数，用来初始化
  // const set = new Set([1, 2, 3, 4, 4]);
  // console.log(set)
  // console.log(set.size) //4

  // 3. 向 Set 加入值的时候，不会发生类型转换
  // 4.Set实例的方法分为两大类： 操作方法(用于操作数据)和遍历方法(用于遍历成员)
  // 4.1 add(value):添加某个值，返回Set结构本身
  // 4.2 delete(value):删除某个值，返回一个布尔值，表示删除是否成功。
  // 4.3 has(value):返回一个布尔值，表示该值是否为Set的成员
  // 4.4 clear():清除所有成员，没有返回值。
} catch (err) {
  _didIteratorError = true;
  _iteratorError = err;
} finally {
  try {
    if (!_iteratorNormalCompletion && _iterator.return) {
      _iterator.return();
    }
  } finally {
    if (_didIteratorError) {
      throw _iteratorError;
    }
  }
}

console.log('--------------4--------------------');
var s1 = new Set();
s1.add(1).add(2).add(3).add(3);
console.log(s1.size); //3
// console.log(s1.has(1))//true
// console.log(s1.has(4))//false
// console.log(s1.delete(2));
// console.log(s1.has(2))

// 5
console.log('---------5---------------------');
// Array.from()方法将Set结构转化为数组
var items = new Set([1, 2, 3, 4]);
var array = Array.from(items);
console.log(array);
// 所以这就提供了去除数组重复成员的另一种方法
// 6.
console.log('--------6 遍历操作--------------');
// 遍历方法
// 6.1. keys():返回键名的遍历器
// 6.2. values(): 返回键值的遍历器
// 6.3. entries(): 返回键值对的遍历器
// 6.4. forEach(): 使用回调函数遍历每个成员
// 注意由于Set没有键值，只有键名，所以sets和values的行为完全一致
var set1 = new Set(['red', 'green', 'blue']);
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;

try {
  for (var _iterator2 = set1.keys()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
    var item = _step2.value;

    console.log(item);
  }
  // red
  // green
  // blue
} catch (err) {
  _didIteratorError2 = true;
  _iteratorError2 = err;
} finally {
  try {
    if (!_iteratorNormalCompletion2 && _iterator2.return) {
      _iterator2.return();
    }
  } finally {
    if (_didIteratorError2) {
      throw _iteratorError2;
    }
  }
}

var _iteratorNormalCompletion3 = true;
var _didIteratorError3 = false;
var _iteratorError3 = undefined;

try {
  for (var _iterator3 = set1.values()[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
    var _item = _step3.value;

    console.log(_item);
  }
  // red
  // green
  // blue
} catch (err) {
  _didIteratorError3 = true;
  _iteratorError3 = err;
} finally {
  try {
    if (!_iteratorNormalCompletion3 && _iterator3.return) {
      _iterator3.return();
    }
  } finally {
    if (_didIteratorError3) {
      throw _iteratorError3;
    }
  }
}

var _iteratorNormalCompletion4 = true;
var _didIteratorError4 = false;
var _iteratorError4 = undefined;

try {
  for (var _iterator4 = set1.entries()[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
    var _item2 = _step4.value;

    console.log(_item2);
  }
  // ["red", "red"]
  // ["green", "green"]
  // ["blue", "blue"]
} catch (err) {
  _didIteratorError4 = true;
  _iteratorError4 = err;
} finally {
  try {
    if (!_iteratorNormalCompletion4 && _iterator4.return) {
      _iterator4.return();
    }
  } finally {
    if (_didIteratorError4) {
      throw _iteratorError4;
    }
  }
}

set1.forEach(function (value, key) {
  console.log(key + ':' + value);
});

var arr1 = [3, 3, 4, 4];
// (...)扩展运算符内部使用 for...of循环
var unique = [].concat(_toConsumableArray(new Set(arr1)));
console.log(unique); // [3, 4]

// console.log('------------------WeakSet---------------------')
// WeakSet结构
// WeakSet 的成员只能是对象，而不能是其他类型的值。
// WeakSet 适合临时存放一组对象,以及存放跟对象绑定的信息

console.log('---------------Map------------------------------');
// javascript中的对象，本质上是键值对的集合
// 它类似于对象，也是键值对的集合，但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键
// 也就是说，Object 结构提供了“字符串—值”的对应，Map 结构提供了“值—值”的对应
var m = new Map();
var o = { p: 'hello' };
m.set(o, 'constant');
console.log(m.get(o));
// 操作方法：has(key), delete(key)
var map = new Map();